edwh-editorjs 2.0.0b1__py3-none-any.whl → 2.0.0b3__py3-none-any.whl

editorjs/__about__.py

@@ -0,0 +1 @@
+__version__ = "2.0.0-beta.3"

editorjs/__init__.py

@@ -0,0 +1,5 @@
+from .core import EditorJS
+
+__all__ = [
+    "EditorJS",
+]

editorjs/blocks.py

@@ -0,0 +1,382 @@
+"""
+mdast to editorjs
+"""
+
+import abc
+import re
+import typing as t
+
+from .exceptions import TODO
+from .types import EditorChildData, MDChildNode
+
+
+class EditorJSBlock(abc.ABC):
+    @classmethod
+    @abc.abstractmethod
+    def to_markdown(cls, data: EditorChildData) -> str: ...
+
+    @classmethod
+    @abc.abstractmethod
+    def to_json(cls, node: MDChildNode) -> list[dict]: ...
+
+    @classmethod
+    @abc.abstractmethod
+    def to_text(cls, node: MDChildNode) -> str: ...
+
+
+BLOCKS: dict[str, EditorJSBlock] = {}
+
+
+def block(*names: str):
+    def wrapper(cls):
+        for name in names:
+            BLOCKS[name] = cls
+        return cls
+
+    return wrapper
+
+
+def process_styled_content(item: MDChildNode, strict: bool = True) -> str:
+    """
+    Processes styled content (e.g., bold, italic) within a list item.
+
+    Args:
+        item: A ChildNode dictionary representing an inline element or text.
+        strict: Raise if 'type' is not one defined in 'html_wrappers'
+
+    Returns:
+        A formatted HTML string based on the item type.
+    """
+    _type = item.get("type")
+    html_wrappers = {
+        "text": "{value}",
+        "html": "{value}",
+        "emphasis": "<i>{value}</i>",
+        "strong": "<b>{value}</b>",
+        "strongEmphasis": "<b><i>{value}</i></b>",
+        "link": '<a href="{url}">{value}</a>',
+        "inlineCode": '<code class="inline-code">{value}</code>',
+        # todo: <mark>
+    }
+
+    if _type in BLOCKS:
+        return BLOCKS[_type].to_text(item)
+
+    if strict and _type not in html_wrappers:
+        raise ValueError(f"Unsupported type {_type} in paragraph")
+
+    # Process children recursively if they exist, otherwise use the direct value
+    if children := item.get("children"):
+        value = "".join(process_styled_content(child) for child in children)
+    else:
+        value = item.get("value", "")
+
+    template = html_wrappers.get(_type, "{value}")
+    return template.format(
+        value=value, url=item.get("url", ""), caption=item.get("caption", "")
+    )
+
+
+def default_to_text(node: MDChildNode):
+    return "".join(
+        process_styled_content(child) for child in node.get("children", [])
+    ) or process_styled_content(node)
+
+
+@block("heading", "header")
+class HeadingBlock(EditorJSBlock):
+    @classmethod
+    def to_markdown(cls, data: EditorChildData) -> str:
+        level = data.get("level", 1)
+        text = data.get("text", "")
+
+        if not (1 <= level <= 6):
+            raise ValueError("Header level must be between 1 and 6.")
+
+        return f"{'#' * level} {text}\n"
+
+    @classmethod
+    def to_json(cls, node: MDChildNode) -> list[dict]:
+        """
+        Converts a Markdown header block into structured block data.
+
+        Args:
+            node: A RootNode dictionary with 'depth' and 'children'.
+
+        Returns:
+            A ChildNode dictionary representing the header data, or None if no children exist.
+
+        Raises:
+            ValueError: If an unsupported heading depth is provided.
+        """
+
+        depth = node.get("depth")
+
+        if depth is None or not (1 <= depth <= 6):
+            raise ValueError("Heading depth must be between 1 and 6.")
+
+        return [{"data": {"level": depth, "text": cls.to_text(node)}, "type": "header"}]
+
+    @classmethod
+    def to_text(cls, node: MDChildNode) -> str:
+        children = node.get("children", [])
+        if children is None or not len(children) == 1:
+            raise ValueError("Header block must have exactly one child element")
+        child = children[0]
+        return child.get("value", "")
+
+
+@block("paragraph")
+class ParagraphBlock(EditorJSBlock):
+    @classmethod
+    def to_markdown(cls, data: EditorChildData) -> str:
+        text = data.get("text", "")
+        return f"{text}\n"
+
+    @classmethod
+    def to_json(cls, node: MDChildNode) -> list[dict]:
+        result = []
+        current_text = ""
+
+        for child in node.get("children"):
+            _type = child.get("type")
+            if _type == "image":
+                if current_text:
+                    result.append({"data": {"text": current_text}, "type": "paragraph"})
+                    current_text = ""
+
+                result.extend(ImageBlock.to_json(child))
+            else:
+                current_text += cls.to_text(child)
+
+        # final text after image:
+        if current_text:
+            result.append({"data": {"text": current_text}, "type": "paragraph"})
+
+        return result
+
+    @classmethod
+    def to_text(cls, node: MDChildNode) -> str:
+        return default_to_text(node)
+
+
+@block("list")
+class ListBlock(EditorJSBlock):
+    @classmethod
+    def to_markdown(cls, data: EditorChildData) -> str:
+        style = data.get("style", "unordered")
+        items = data.get("items", [])
+
+        def parse_items(subitems: list[dict[str, t.Any]], depth: int = 0) -> str:
+            markdown_items = []
+            for index, item in enumerate(subitems):
+                prefix = f"{index + 1}." if style == "ordered" else "-"
+                line = f"{'\t' * depth}{prefix} {item['content']}"
+                markdown_items.append(line)
+
+                # Recurse if there are nested items
+                if item.get("items"):
+                    markdown_items.append(parse_items(item["items"], depth + 1))
+
+            return "\n".join(markdown_items)
+
+        return "\n" + parse_items(items) + "\n"
+
+    @classmethod
+    def to_json(cls, node: MDChildNode) -> list[dict]:
+        """
+        Converts a Markdown list block with nested items and styling into structured block data.
+
+        Args:
+            node: A RootNode dictionary with 'ordered' and 'children'.
+
+        Returns:
+            A dictionary representing the structured list data with 'items' and 'style'.
+        """
+        items = []
+        # checklists are not supported (well) by mdast
+        # so we detect it ourselves:
+        could_be_checklist = True
+
+        def is_checklist(value: str) -> bool:
+            return value.strip().startswith(("[ ]", "[x]"))
+
+        for child in node["children"]:
+            content = ""
+            subitems = []
+            # child can have content and/or items
+            for grandchild in child["children"]:
+                _type = grandchild.get("type", "")
+                if _type == "paragraph":
+                    subcontent = ParagraphBlock.to_text(grandchild)
+                    could_be_checklist = could_be_checklist and is_checklist(subcontent)
+                    content += "" + subcontent
+                elif _type == "list":
+                    could_be_checklist = False
+                    subitems.extend(ListBlock.to_json(grandchild)[0]["data"]["items"])
+                else:
+                    raise ValueError(f"Unsupported type {_type} in list")
+
+            items.append(
+                {
+                    "content": content,
+                    "items": subitems,
+                }
+            )
+
+        # todo: detect 'checklist':
+        """
+        type: checklist
+        data: {items: [{text: "a", checked: false}, {text: "b", checked: false}, {text: "c", checked: true},…]}
+        """
+
+        if could_be_checklist:
+            return [
+                {
+                    "type": "checklist",
+                    "data": {
+                        "items": [
+                            {
+                                "text": x["content"]
+                                .removeprefix("[ ] ")
+                                .removeprefix("[x] "),
+                                "checked": x["content"].startswith("[x]"),
+                            }
+                            for x in items
+                        ]
+                    },
+                }
+            ]
+        else:
+            return [
+                {
+                    "data": {
+                        "items": items,
+                        "style": "ordered" if node.get("ordered") else "unordered",
+                    },
+                    "type": "list",
+                }
+            ]
+
+    @classmethod
+    def to_text(cls, node: MDChildNode) -> str:
+        return ""
+
+
+@block("checklist")
+class ChecklistBlock(ListBlock):
+    @classmethod
+    def to_markdown(cls, data: EditorChildData) -> str:
+        markdown_items = []
+
+        for item in data.get("items", []):
+            text = item.get("text", "").strip()
+            char = "x" if item.get("checked", False) else " "
+            markdown_items.append(f"- [{char}] {text}")
+
+        return "\n" + "\n".join(markdown_items) + "\n"
+
+
+@block("thematicBreak", "delimiter")
+class DelimiterBlock(EditorJSBlock):
+    @classmethod
+    def to_markdown(cls, data: EditorChildData) -> str:
+        return "***\n"
+
+    @classmethod
+    def to_json(cls, node: MDChildNode) -> list[dict]:
+        return [
+            {
+                "type": "delimiter",
+                "data": {},
+            }
+        ]
+
+    @classmethod
+    def to_text(cls, node: MDChildNode) -> str:
+        return ""
+
+
+@block("code")
+class CodeBlock(EditorJSBlock):
+    @classmethod
+    def to_markdown(cls, data: EditorChildData) -> str:
+        code = data.get("code", "")
+        return f"```\n" f"{code}" f"\n```\n"
+
+    @classmethod
+    def to_json(cls, node: MDChildNode) -> list[dict]:
+        return [
+            {
+                "data": {"code": cls.to_text(node)},
+                "type": "code",
+            }
+        ]
+
+    @classmethod
+    def to_text(cls, node: MDChildNode) -> str:
+        return node.get("value", "")
+
+
+@block("image")
+class ImageBlock(EditorJSBlock):
+    @classmethod
+    def to_markdown(cls, data: EditorChildData) -> str:
+        url = data.get("url", "") or data.get("file", {}).get("url", "")
+        caption = data.get("caption", "")
+        return f"""![{caption}]({url} "{caption}")\n"""
+
+    @classmethod
+    def to_json(cls, node: MDChildNode) -> list[dict]:
+        return [
+            {
+                "type": "image",
+                "data": {
+                    "caption": cls.to_text(node),
+                    "file": {"url": node.get("url")},
+                },
+            }
+        ]
+
+    @classmethod
+    def to_text(cls, node: MDChildNode) -> str:
+        return node.get("alt") or node.get("caption") or ""
+
+
+@block("blockquote", "quote")
+class QuoteBlock(EditorJSBlock):
+    re_cite = re.compile(r"<cite>(.+?)<\/cite>")
+
+    @classmethod
+    def to_markdown(cls, data: EditorChildData) -> str:
+        text = data.get("text", "")
+        result = f"> {text}\n"
+        if caption := data.get("caption", ""):
+            result += f"> <cite>{caption}</cite>\n"
+        return result
+
+    @classmethod
+    def to_json(cls, node: MDChildNode) -> list[dict]:
+        caption = ""
+        text = cls.to_text(node).replace("\n", "<br/>\n")
+
+        if cite := re.search(cls.re_cite, text):
+            # Capture the value of the first group
+            caption = cite.group(1)
+            # Remove the <cite>...</cite> tags from the text
+            text = re.sub(cls.re_cite, "", text)
+
+        return [
+            {
+                "data": {
+                    "alignment": "left",
+                    "caption": caption,
+                    "text": text,
+                },
+                "type": "quote",
+            }
+        ]
+
+    @classmethod
+    def to_text(cls, node: MDChildNode) -> str:
+        return default_to_text(node)

editorjs/core.py

@@ -0,0 +1,116 @@
+import json
+import textwrap
+import typing as t
+
+import markdown2
+import mdast
+from typing_extensions import Self
+
+from .blocks import BLOCKS
+from .exceptions import TODO
+from .helpers import unix_timestamp
+from .types import MDRootNode
+
+EDITORJS_VERSION = "2.30.6"
+
+
+class EditorJS:
+    # internal representation is mdast, because we can convert to other types
+    _mdast: MDRootNode
+
+    def __init__(self, _mdast: str | dict, extras: list = ("task_list", "fenced-code-blocks")):
+        if not isinstance(_mdast, str | dict):
+            raise TypeError("Only `str` or `dict` is supported!")
+
+        self._mdast = t.cast(
+            MDRootNode, json.loads(_mdast) if isinstance(_mdast, str) else _mdast
+        )
+
+        self._md = markdown2.Markdown(extras=extras)  # todo: striketrough, table, ?
+
+    @classmethod
+    def from_json(cls, data: str | dict) -> Self:
+        """
+        Load from EditorJS JSON Blocks
+        """
+        data = data if isinstance(data, dict) else json.loads(data)
+        markdown_items = []
+        for child in data["blocks"]:
+            _type = child["type"]
+            if not (block := BLOCKS.get(_type)):
+                raise TypeError(f"Unsupported block type `{_type}`")
+
+            markdown_items.append(block.to_markdown(child.get("data", {})))
+
+        markdown = "".join(markdown_items)
+        return cls.from_markdown(markdown)
+
+    @classmethod
+    def from_markdown(cls, data: str) -> Self:
+        """
+        Load from markdown string
+        """
+
+        return cls(mdast.md_to_json(data))
+
+    @classmethod
+    def from_mdast(cls, data: str | dict) -> Self:
+        """
+        Existing mdast representation
+        """
+        return cls(data)
+
+    def to_json(self) -> str:
+        """
+        Export EditorJS JSON Blocks
+        """
+        # logic based on https://github.com/carrara88/editorjs-md-parser/blob/main/src/MarkdownImporter.js
+        blocks = []
+        for child in self._mdast["children"]:
+            _type = child["type"]
+            if not (block := BLOCKS.get(_type)):
+                raise TypeError(f"Unsupported block type `{_type}`")
+
+            blocks.extend(block.to_json(child))
+
+        data = {"time": unix_timestamp(), "blocks": blocks, "version": EDITORJS_VERSION}
+
+        return json.dumps(data)
+
+    def to_markdown(self) -> str:
+        """
+        Export Markdown string
+        """
+        md = mdast.json_to_md(self.to_mdast())
+        # idk why this happens:
+        md = md.replace(r"\[ ]", "[ ]")
+        md = md.replace(r"\[x]", "[x]")
+        return md
+
+    def to_mdast(self) -> str:
+        """
+        Export mdast representation
+        """
+        return json.dumps(self._mdast)
+
+    def to_html(self) -> str:
+        """
+        Export HTML string
+        """
+        md = self.to_markdown()
+        return self._md.convert(md)
+
+    def __repr__(self):
+        md = self.to_markdown()
+        md = md.replace("\n", "\\n")
+        return f"EditorJS({md})"
+
+    def __str__(self):
+        return self.to_markdown()
+
+    # def __eq__(self, other: Self) -> bool:
+    #     a = self.to_markdown()
+    #     b = other.to_markdown()
+    #
+    #     remove = string.punctuation + string.whitespace
+    #     return a.translate(remove) == b.translate(remove)

editorjs/exceptions.py

@@ -0,0 +1,3 @@
+class TODO(NotImplementedError):
+    def __init__(self, msg: str = "todo"):
+        super().__init__(msg)

editorjs/helpers.py

@@ -0,0 +1,5 @@
+import time
+
+
+def unix_timestamp():
+    return round(time.time() * 1000)

editorjs/types.py

@@ -0,0 +1,43 @@
+import typing as t
+
+
+class MDPosition(t.TypedDict):
+    line: int
+    column: int
+    offset: int
+
+
+class MDPositionRange(t.TypedDict):
+    start: MDPosition
+    end: MDPosition
+
+
+class MDChildNode(t.TypedDict, total=False):
+    type: str  # General identifier for node types
+    children: list["MDChildNode"]  # Recursive children of any node type
+    position: MDPositionRange
+    value: str  # Optional, for nodes like text that hold a value
+    depth: int  # Optional, for nodes like headings that have a depth
+    url: t.NotRequired[str]
+
+
+class MDRootNode(t.TypedDict):
+    type: t.Literal["root"]  # Constrains to 'root' for the root node
+    children: list[MDChildNode]  # Allows any ChildNode type in children
+    position: MDPositionRange
+
+
+class EditorChildData(t.TypedDict, total=False):
+    text: str
+    items: list["EditorChildNode"]
+
+
+class EditorChildNode(t.TypedDict):
+    type: str
+    data: EditorChildData
+
+
+class EditorRootNode(t.TypedDict):
+    time: int
+    blocks: list[EditorChildNode]
+    version: str

edwh_editorjs-2.0.0b3.dist-info/METADATA

@@ -0,0 +1,28 @@
+Metadata-Version: 2.3
+Name: edwh-editorjs
+Version: 2.0.0b3
+Summary: EditorJS.py
+Project-URL: Homepage, https://github.com/educationwarehouse/edwh-EditorJS
+Author-email: SKevo <skevo.cw@gmail.com>, Robin van der Noord <robin.vdn@educationwarehouse.nl>
+License: MIT
+License-File: LICENSE
+Keywords: bleach,clean,editor,editor.js,html,javascript,json,parser,wysiwyg
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.10
+Requires-Dist: markdown2
+Requires-Dist: mdast
+Provides-Extra: dev
+Requires-Dist: edwh; extra == 'dev'
+Requires-Dist: hatch; extra == 'dev'
+Requires-Dist: su6[all]; extra == 'dev'
+Requires-Dist: types-bleach; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# edwh-editorjs
+

edwh_editorjs-2.0.0b3.dist-info/RECORD

@@ -0,0 +1,11 @@
+editorjs/__about__.py,sha256=TTjbddHImhhMSF_k6S9WFgA-Fcil370fw4WeR8a-eBk,29
+editorjs/__init__.py,sha256=-OHUf7ZXfkbdFB1r85eIjpHRfql-GCNUCKuBEdEt2Rc,58
+editorjs/blocks.py,sha256=WTtzsflkbhkZhjYQ6vZ_6Frl66ZU9uUbWwnX4mGzu4c,11341
+editorjs/core.py,sha256=_mr-WJ2QgB2drgBLnPM38DAPTaxZba--H_EWiQcAZMY,3264
+editorjs/exceptions.py,sha256=TyfHvk2Z5RbKxTDK7lrjgwAgVgInXIuDW63eO5jzVFw,106
+editorjs/helpers.py,sha256=q861o5liNibMTp-Ozay17taF7CTNsRe901lYhhxdwHg,73
+editorjs/types.py,sha256=W7IZWMWgzJaQulybIt0Gx5N63rVj4mEy73VJWo4VAQA,1029
+edwh_editorjs-2.0.0b3.dist-info/METADATA,sha256=QeUtRWqC6v8mGhkm16JoFJ78KhFW0mSEhxHifKTmYjI,1009
+edwh_editorjs-2.0.0b3.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+edwh_editorjs-2.0.0b3.dist-info/licenses/LICENSE,sha256=zzllbk0pvnmgzk31iq8Zkg0GkA8vVx_Zc3OHjVlTjxo,1101
+edwh_editorjs-2.0.0b3.dist-info/RECORD,,

{edwh_editorjs-2.0.0b1.dist-info → edwh_editorjs-2.0.0b3.dist-info}/licenses/LICENSE

@@ -1,6 +1,7 @@
 MIT License
 
 Copyright (c) 2021 SKevo
+Copyright (c) 2024 Education Warehouse
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

edwh_editorjs-2.0.0b1.dist-info/METADATA

@@ -1,104 +0,0 @@
-Metadata-Version: 2.3
-Name: edwh-editorjs
-Version: 2.0.0b1
-Summary: pyEditorJS
-Project-URL: Homepage, https://github.com/educationwarehouse/edwh-EditorJS
-Author-email: SKevo <skevo.cw@gmail.com>, Robin van der Noord <robin.vdn@educationwarehouse.nl>
-License: MIT
-License-File: LICENSE
-Keywords: bleach,clean,editor,editor.js,html,javascript,json,parser,wysiwyg
-Classifier: Development Status :: 4 - Beta
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Requires-Python: >=3.10
-Requires-Dist: bleach
-Provides-Extra: dev
-Requires-Dist: edwh; extra == 'dev'
-Requires-Dist: hatch; extra == 'dev'
-Requires-Dist: su6[all]; extra == 'dev'
-Requires-Dist: types-bleach; extra == 'dev'
-Description-Content-Type: text/markdown
-
-# edwh-editorjs
-
-A minimal, fast Python 3.10+ package for parsing [Editor.js](https://editorjs.io) content.
-This package is a fork of [pyEditorJS by SKevo](https://github.com/SKevo18/pyEditorJS) with additional capabilities.
-
-## New Features
-
-- Expanded support for additional block types: Quote, Table, Code, Warning, and Raw blocks
-- Issues a warning if an unknown block type is encountered, rather than ignoring it
-- Adds a `strict` mode, raising an `EditorJSUnsupportedBlock` exception for unknown block types when `strict=True`
-- Allows adding new blocks by decorating a subclass of `EditorJsParser` with `@block("name")`
-
-## Installation
-
-```bash
-pip install edwh-editorjs
-```
-
-## Usage
-
-### Quickstart
-
-```python
-from pyeditorjs import EditorJsParser
-
-editor_js_data = ...  # your Editor.js JSON data
-parser = EditorJsParser(editor_js_data)  # initialize the parser
-
-html = parser.html(sanitize=True)  # `sanitize=True` uses the included `bleach` dependency
-print(html)  # your clean HTML
-```
-
-### Enforcing Strict Block Types
-
-```python
-from pyeditorjs import EditorJsParser, EditorJSUnsupportedBlock
-
-editor_js_data: dict = ...
-parser = EditorJsParser(editor_js_data)
-
-try:
-    html = parser.html(strict=True)
-except EditorJSUnsupportedBlock as e:
-    print(f"Unsupported block type encountered: {e}")
-```
-
-### Adding a Custom Block
-
-To add a custom block type, create a new class that subclasses `EditorJsBlock` and decorates it with `@block("name")`,
-where `"name"` is the custom block type. Implement an `html` method to define how the block’s content should be
-rendered. This method should accept a `sanitize` parameter and can access block data via `self.data`.
-
-```python
-from pyeditorjs import EditorJsParser, EditorJsBlock, block
-
-@block("custom")
-class CustomBlock(EditorJsBlock):
-    def html(self, sanitize: bool = False) -> str:
-        # Access data with self.data and return the rendered HTML
-        content = self.data.get("something", "")
-        if sanitize:
-            content = self.sanitize(content)
-        
-        return f"<div class='custom-block'>{content}</div>"
-
-# Usage
-class CustomEditorJsParser(EditorJsParser):
-    pass  # Custom blocks are automatically detected
-
-editor_js_data = ...  # Editor.js JSON data with a "customBlock" type
-parser = CustomEditorJsParser(editor_js_data)
-html = parser.html()
-print(html)  # Includes rendered custom blocks
-```
-
-## Disclaimer
-
-This is a community-provided project and is not affiliated with the Editor.js team. 
-Contributions, bug reports, and suggestions are welcome!

edwh_editorjs-2.0.0b1.dist-info/RECORD

@@ -1,9 +0,0 @@
-pyeditorjs/__about__.py,sha256=I5vqr3Wm1FBwrGe3laM0fzEEDA_k4QsjCkyWUujPHec,29
-pyeditorjs/__init__.py,sha256=63UoNCWJo6NuPXXYnANQE3SKm1PQu2ggs89KCXSq-44,807
-pyeditorjs/blocks.py,sha256=4A8dXbh_oUKCctOHtMV6BrR7-UpyqFREPvwPEe_6vUo,8304
-pyeditorjs/exceptions.py,sha256=Uni8r3FwJ-6xQIdSmBsHLs_htWLHD0Arp1KJEvjGU1U,439
-pyeditorjs/parser.py,sha256=6DCqqi-FuXDFxn9xb-dgQ19alvVu7Pjx6x3rTAx9IsI,2154
-edwh_editorjs-2.0.0b1.dist-info/METADATA,sha256=4vIO1CBWAasUZ_JaZzm7E_FSE1s-x3LZeO_4rKfvhec,3521
-edwh_editorjs-2.0.0b1.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-edwh_editorjs-2.0.0b1.dist-info/licenses/LICENSE,sha256=bY9MhHLeuW8w1aAl-i1O1uSNP5IMOGaL6AWvHcdnt0k,1062
-edwh_editorjs-2.0.0b1.dist-info/RECORD,,

pyeditorjs/__about__.py

@@ -1 +0,0 @@
-__version__ = "2.0.0-beta.1"

pyeditorjs/__init__.py

@@ -1,30 +0,0 @@
-from pathlib import Path
-
-from .blocks import BLOCKS_MAP, EditorJsBlock, block
-from .exceptions import EditorJsException, EditorJsParseError, EditorJSUnsupportedBlock
-from .parser import EditorJsParser
-
-__all__ = [
-    "EditorJsParser",
-    "EditorJsParseError",
-    "EditorJsException",
-    "EditorJSUnsupportedBlock",
-    "EditorJsBlock",
-    "block",
-    "BLOCKS_MAP",
-]
-
-
-# Overwrite __doc__ with README, so that pdoc can render it:
-README_PATH = Path(__file__).parent.parent.absolute() / Path("README.md")
-try:
-    with open(README_PATH, "r", encoding="UTF-8") as readme:
-        __readme__ = readme.read()
-except Exception:
-    __readme__ = "Failed to read README.md!"  # fallback message, for example when there's no README
-
-__doc__ = __readme__
-
-
-if __name__ == "__main__":
-    _ = [EditorJsParser]

pyeditorjs/blocks.py

@@ -1,313 +0,0 @@
-import abc
-import typing as t
-from dataclasses import dataclass
-
-import bleach
-
-from .exceptions import EditorJsParseError
-
-__all__ = [
-    "block",
-    "BLOCKS_MAP",
-    "EditorJsBlock",
-]
-
-
-def _sanitize(html: str) -> str:
-    return bleach.clean(
-        html,
-        tags=["b", "i", "u", "a", "mark", "code"],
-        attributes=["class", "data-placeholder", "href"],
-    )
-
-
-BLOCKS_MAP: t.Dict[str, t.Type["EditorJsBlock"]] = {
-    # 'header': HeaderBlock,
-    # 'paragraph': ParagraphBlock,
-    # 'list': ListBlock,
-    # 'delimiter': DelimiterBlock,
-    # 'image': ImageBlock,
-}
-
-
-def block(_type: str):
-    def wrapper(cls: t.Type["EditorJsBlock"]):
-        BLOCKS_MAP[_type] = cls
-        return cls
-
-    return wrapper
-
-
-@dataclass
-class EditorJsBlock(abc.ABC):
-    """
-    A generic parsed Editor.js block
-    """
-
-    _data: dict
-    """The raw JSON data of the entire block"""
-
-    @classmethod
-    def sanitize(cls, html: str) -> str:
-        return _sanitize(html)
-
-    @property
-    def id(self) -> t.Optional[str]:
-        """
-        Returns ID of the block, generated client-side.
-        """
-
-        return self._data.get("id", None)
-
-    @property
-    def type(self) -> t.Optional[str]:
-        """
-        Returns the type of the block.
-        """
-
-        return self._data.get("type", None)
-
-    @property
-    def data(self) -> dict:
-        """
-        Returns the actual block data.
-        """
-
-        return self._data.get("data", {})
-
-    @abc.abstractmethod
-    def html(self, sanitize: bool = False) -> str:
-        """
-        Returns the HTML representation of the block.
-
-        ### Parameters:
-        - `sanitize` - if `True`, then the block's text/contents will be sanitized.
-        """
-
-        raise NotImplementedError()
-
-
-@block("header")
-class HeaderBlock(EditorJsBlock):
-    VALID_HEADER_LEVEL_RANGE = range(1, 7)
-    """Valid range for header levels. Default is `range(1, 7)` - so, `0` - `6`."""
-
-    @property
-    def text(self) -> str:
-        """
-        Returns the header's text.
-        """
-
-        return self.data.get("text", "")
-
-    @property
-    def level(self) -> int:
-        """
-        Returns the header's level (`0` - `6`).
-        """
-
-        _level = self.data.get("level", 1)
-
-        if not isinstance(_level, int) or _level not in self.VALID_HEADER_LEVEL_RANGE:
-            raise EditorJsParseError(f"`{_level}` is not a valid header level.")
-
-        return _level
-
-    def html(self, sanitize: bool = False) -> str:
-        text = self.text
-        if sanitize:
-            text = _sanitize(text)
-        return rf'<h{self.level} class="cdx-block ce-header">{text}</h{self.level}>'
-
-
-@block("paragraph")
-class ParagraphBlock(EditorJsBlock):
-    @property
-    def text(self) -> str:
-        """
-        The text content of the paragraph.
-        """
-
-        return self.data.get("text", "")
-
-    def html(self, sanitize: bool = False) -> str:
-        return rf'<p class="cdx-block ce-paragraph">{_sanitize(self.text) if sanitize else self.text}</p>'
-
-
-@block("list")
-class ListBlock(EditorJsBlock):
-    VALID_STYLES = ("unordered", "ordered")
-    """Valid list order styles."""
-
-    @property
-    def style(self) -> t.Optional[str]:
-        """
-        The style of the list. Can be `ordered` or `unordered`.
-        """
-
-        return self.data.get("style", None)
-
-    @property
-    def items(self) -> t.List[str]:
-        """
-        Returns the list's items, in raw format.
-        """
-
-        return self.data.get("items", [])
-
-    def html(self, sanitize: bool = False) -> str:
-        if self.style not in self.VALID_STYLES:
-            raise EditorJsParseError(f"`{self.style}` is not a valid list style.")
-
-        _items = [
-            f"<li>{_sanitize(item) if sanitize else item}</li>" for item in self.items
-        ]
-        _type = "ul" if self.style == "unordered" else "ol"
-        _items_html = "".join(_items)
-
-        return rf'<{_type} class="cdx-block cdx-list cdx-list--{self.style}">{_items_html}</{_type}>'
-
-
-@block("delimiter")
-class DelimiterBlock(EditorJsBlock):
-    def html(self, sanitize: bool = False) -> str:
-        return r'<div class="cdx-block ce-delimiter"></div>'
-
-
-@block("image")
-class ImageBlock(EditorJsBlock):
-    @property
-    def file_url(self) -> str:
-        """
-        URL of the image file.
-        """
-
-        return self.data.get("file", {}).get("url", "")
-
-    @property
-    def caption(self) -> str:
-        """
-        The image's caption.
-        """
-
-        return self.data.get("caption", "")
-
-    @property
-    def with_border(self) -> bool:
-        """
-        Whether the image has a border.
-        """
-
-        return self.data.get("withBorder", False)
-
-    @property
-    def stretched(self) -> bool:
-        """
-        Whether the image is stretched.
-        """
-
-        return self.data.get("stretched", False)
-
-    @property
-    def with_background(self) -> bool:
-        """
-        Whether the image has a background.
-        """
-
-        return self.data.get("withBackground", False)
-
-    def html(self, sanitize: bool = False) -> str:
-        if self.file_url.startswith("data:image/"):
-            _img = self.file_url
-        else:
-            _img = _sanitize(self.file_url) if sanitize else self.file_url
-
-        parts = [
-            rf'<div class="cdx-block image-tool image-tool--filled {"image-tool--stretched" if self.stretched else ""} {"image-tool--withBorder" if self.with_border else ""} {"image-tool--withBackground" if self.with_background else ""}">'
-            r'<div class="image-tool__image">',
-            r'<div class="image-tool__image-preloader"></div>',
-            rf'<img class="image-tool__image-picture" src="{_img}"/>',
-            r"</div>"
-            rf'<div class="image-tool__caption" data-placeholder="{_sanitize(self.caption) if sanitize else self.caption}"></div>'
-            r"</div>"
-            r"</div>",
-        ]
-
-        return "".join(parts)
-
-
-@block("quote")
-class QuoteBlock(EditorJsBlock):
-    def html(self, sanitize: bool = False) -> str:
-        quote = self.data.get("text", "")
-        caption = self.data.get("caption", "")
-        if sanitize:
-            quote = _sanitize(quote)
-            caption = _sanitize(caption)
-        _alignment = self.data.get("alignment", "left")  # todo
-        return f"""
-        <blockquote class="cdx-block cdx-quote">
-            <div class="cdx-input cdx-quote__text">{quote}</div>
-            <cite class="cdx-input cdx-quote__caption">{caption}</cite>
-        </blockquote>
-        """
-
-
-@block("table")
-class TableBlock(EditorJsBlock):
-    def html(self, sanitize: bool = False) -> str:
-        content = self.data.get("content", [])
-        _stretched = self.data.get("stretched", False)  # todo
-        _with_headings = self.data.get("withHeadings", False)  # todo
-
-        html_table = '<table class="tc-table">'
-
-        # Add content rows
-        for row in content:
-            html_table += '<tr class="tc-row">'
-            for cell in row:
-                html_table += (
-                    f'<td class="tc-cell">{_sanitize(cell) if sanitize else cell}</td>'
-                )
-            html_table += "</tr>"
-
-        html_table += "</table>"
-        return html_table
-
-
-@block("code")
-class CodeBlock(EditorJsBlock):
-    def html(self, sanitize: bool = False) -> str:
-        code = self.data.get("code", "")
-        if sanitize:
-            code = _sanitize(code)
-        return f"""
-        <code class="ce-code__textarea cdx-input" data-empty="false">{code}</code>
-        """
-
-
-@block("warning")
-class WarningBlock(EditorJsBlock):
-    def html(self, sanitize: bool = False) -> str:
-        title = self.data.get("title", "")
-        message = self.data.get("message", "")
-
-        if sanitize:
-            title = _sanitize(title)
-            message = _sanitize(message)
-
-        return f"""
-            <div class="cdx-block cdx-warning">
-                <div class="cdx-input cdx-warning__title">{title}</div>
-                <div class="cdx-input cdx-warning__message">{message}</div>
-            </div>
-        """
-
-
-@block("raw")
-class RawBlock(EditorJsBlock):
-    def html(self, sanitize: bool = False) -> str:
-        html = self.data.get("html", "")
-        if sanitize:
-            html = _sanitize(html)
-        return html

pyeditorjs/exceptions.py

@@ -1,19 +0,0 @@
-__all__ = [
-    "EditorJsException",
-    "EditorJsParseError",
-    "EditorJSUnsupportedBlock",
-]
-
-
-class EditorJsException(Exception):
-    """
-    Base exception
-    """
-
-
-class EditorJsParseError(EditorJsException):
-    """Raised when a parse error occurs (example: the JSON data has invalid or malformed content)."""
-
-
-class EditorJSUnsupportedBlock(EditorJsException):
-    """Raised when strict=True and using an unknown block type."""

pyeditorjs/parser.py

@@ -1,75 +0,0 @@
-import typing as t
-import warnings
-from dataclasses import dataclass
-
-from .blocks import BLOCKS_MAP, EditorJsBlock
-from .exceptions import EditorJsParseError, EditorJSUnsupportedBlock
-
-
-@dataclass
-class EditorJsParser:
-    """
-    An Editor.js parser.
-    """
-
-    content: dict
-    """The JSON data of Editor.js content."""
-
-    def __post_init__(self) -> None:
-        if not isinstance(self.content, dict):
-            raise EditorJsParseError(
-                f"Content must be `dict`, not {type(self.content).__name__}"
-            )
-
-    @staticmethod
-    def _get_block(data: dict, strict: bool = False) -> t.Optional[EditorJsBlock]:
-        """
-        Obtains block instance from block data.
-        """
-
-        _type = data.get("type", None)
-
-        if _type not in BLOCKS_MAP:
-            if strict:
-                raise EditorJSUnsupportedBlock(_type)
-            else:
-                warnings.warn(f"Unsupported block: {_type}", category=RuntimeWarning)
-                return None
-
-        return BLOCKS_MAP[_type](_data=data)
-
-    def blocks(self, strict: bool = False) -> list[EditorJsBlock]:
-        """
-        Obtains a list of all available blocks from the editor's JSON data.
-        """
-
-        all_blocks: list[EditorJsBlock] = []
-        blocks = self.content.get("blocks", [])
-
-        if not isinstance(blocks, list):
-            raise EditorJsParseError(
-                f"Blocks is not `list`, but `{type(blocks).__name__}`"
-            )
-
-        for block_data in blocks:
-            if block := self._get_block(data=block_data, strict=strict):
-                all_blocks.append(block)
-
-        return all_blocks
-
-    def __iter__(self) -> t.Iterator[EditorJsBlock]:
-        """Returns `iter(self.blocks())`"""
-
-        return iter(self.blocks())
-
-    def html(self, sanitize: bool = False, strict: bool = False) -> str:
-        """
-        Renders the editor's JSON content as HTML.
-
-        ### Parameters:
-        - `sanitize` - whether to also sanitize the blocks' texts/contents.
-        """
-
-        return "\n".join(
-            [block.html(sanitize=sanitize) for block in self.blocks(strict=strict)]
-        )